The invention is generally related to computers and computer software. More specifically, the invention is generally related to monitoring break points used during debugging software, especially in a multi-threaded software environment.
Locating, analyzing and correcting suspected faults in a computer program is a process known as xe2x80x9cdebugging.xe2x80x9d Typically, a programmer uses another computer program commonly known as a xe2x80x9cdebuggerxe2x80x9d to debug a program under development.
Conventional debuggers typically support two primary operations to assist a computer programmer. A first operation supported by conventional debuggers is a xe2x80x9cstepxe2x80x9d function, which permits a computer programmer to process instructions (also known as xe2x80x9cstatementsxe2x80x9d) in a computer program one-by-one, and see the results upon completion of each instruction. While the step operation provides a programmer with a large amount of information about a program during its execution, stepping through hundreds or thousands of program instructions can be extremely tedious and time consuming, and may require a programmer to step through many program instructions that are known to be error-free before a set of instructions to be analyzed are executed.
To address this difficulty, a second operation supported by conventional debuggers is a break point operation, which permits a computer programmer to identify with a xe2x80x9cbreak pointxe2x80x9d a precise instruction for which it is desired to halt execution of a computer program during execution. As a result, when a computer program is executed by a debugger, the program executes in a normal fashion until a break point is reached, and then stops execution and displays the results of the computer program to the programmer for analysis.
Typically, step operations and break points are used together to simplify the debugging process. Specifically, a common debugging operation is to set a break point at the beginning of a desired set of instructions to be analyzed, and then begin executing the program. Once the break point is reached, the program is halted, and the programmer then steps through the desired set of instructions line by line using the step operation. Consequently, a programmer is able to quickly isolate and analyze a particular set of instructions without having to step through irrelevant portions of a computer program.
Most break points supported by conventional debuggers are unconditional, meaning that once such a break point is reached, execution of the program is always halted. Some debuggers also support the use of conditional break points, which only halt execution of a program when a variable used by the program is set to a predetermined value at the time such a break point is reached.
Some operating systems, such as UNIX and Windows NT, allow multiple parts, or threads, of one or more processes to run simultaneously. These operating systems are referred to as multi-threaded. This type of parallel processing allows for faster execution of such processes. However, multi-threaded operating systems complicate debugging by making use of break points inefficient. Conventional multi-thread debuggers do not identify the activities of the various control threads. The insight given is limited to listing thread identifiers without any relation to their activities. The user often must painfully set and hit each of a large number of break points to deduce what each thread is doing.
Therefore, a significant need exists for a manner of monitoring the activities of threads so that multi-threaded applications can be debugged more readily.
The invention addresses these and other problems associated with the prior art by providing an apparatus, program product, and method of debugging a multi-threaded computer program that identify, during execution of the program, threads utilizing program elements such as instructions or variables.
In an illustrative embodiment of the invention, a control point such as a thread identification control point is inserted into the computer program at the location of a particular program element. When a thread identification control point is encountered during program execution, the identifier for the thread causing this encounter is associated with the control point. Then, after program execution is halted, e.g., by a break point, the user may request retrieval of the thread identifiers associated with the control point.
One advantage of identifying threads in the manner disclosed herein is that the activities of the threads becomes more apparent to a user. For example, a user is given insight into which threads read or set a variable or executed certain code. The user need not painfully deduce the thread activities by inserting and monitoring a large number of break points, as would otherwise be required by conventional implementations.
These and other advantages and features, which characterize the invention, are set forth in the claims annexed hereto and forming a further part hereof. However, for a better understanding of the invention, and of the advantages and objectives attained through its use, reference should be made to the drawings, and to the accompanying descriptive matter, in which there are described various embodiments of the invention.